home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / cg.lha / cg / m2c / TreeMod2.c < prev    next >
C/C++ Source or Header  |  1992-11-24  |  55KB  |  1,599 lines
  1. #include "SYSTEM_.h"
  2.  
  3. #ifndef DEFINITION_System
  4. #include "System.h"
  5. #endif
  6.  
  7. #ifndef DEFINITION_IO
  8. #include "IO.h"
  9. #endif
  10.  
  11. #ifndef DEFINITION_Tree
  12. #include "Tree.h"
  13. #endif
  14.  
  15. #ifndef DEFINITION_IO
  16. #include "IO.h"
  17. #endif
  18.  
  19. #ifndef DEFINITION_Sets
  20. #include "Sets.h"
  21. #endif
  22.  
  23. #ifndef DEFINITION_Idents
  24. #include "Idents.h"
  25. #endif
  26.  
  27. #ifndef DEFINITION_Positions
  28. #include "Positions.h"
  29. #endif
  30.  
  31. #ifndef DEFINITION_Tree
  32. #include "Tree.h"
  33. #endif
  34.  
  35. #ifndef DEFINITION_TreeMod2
  36. #include "TreeMod2.h"
  37. #endif
  38.  
  39. Tree_tTree TreeMod2_Iterator;
  40. IO_tFile TreeMod2_yyf;
  41. PROC TreeMod2_Exit;
  42.  
  43. static Idents_tIdent iClassName;
  44. static Tree_tTree RevChild;
  45. static void yyAbort ARGS((CHAR yyFunction[], LONGCARD ));
  46. static BOOLEAN yyIsEqual ARGS((BYTE yya[], LONGCARD , BYTE yyb[], LONGCARD ));
  47. struct S_3 {
  48.     union {
  49.         char dummy;
  50.     } U_1;
  51. };
  52. static void WriteNodeName ARGS((Tree_tTree t));
  53. struct S_4 {
  54.     union {
  55.         char dummy;
  56.     } U_1;
  57. };
  58. static void WriteNode ARGS((Tree_tTree t));
  59. struct S_5 {
  60.     union {
  61.         char dummy;
  62.     } U_1;
  63. };
  64. static void Mark ARGS((Tree_tTree t));
  65. struct S_6 {
  66.     union {
  67.         char dummy;
  68.     } U_1;
  69. };
  70. static void WriteClassName ARGS((Tree_tTree t));
  71. struct S_7 {
  72.     union {
  73.         char dummy;
  74.     } U_1;
  75. };
  76. static void WriteAttributes ARGS((Tree_tTree t));
  77. struct S_8 {
  78.     union {
  79.         char dummy;
  80.     } U_1;
  81. };
  82. static void ReadAttributes ARGS((Tree_tTree t));
  83. struct S_9 {
  84.     union {
  85.         char dummy;
  86.     } U_1;
  87. };
  88. static void PutAttributes ARGS((Tree_tTree t));
  89. struct S_10 {
  90.     union {
  91.         char dummy;
  92.     } U_1;
  93. };
  94. static void GetAttributes ARGS((Tree_tTree t));
  95. struct S_11 {
  96.     union {
  97.         char dummy;
  98.     } U_1;
  99. };
  100. static void InitKindToIdent ARGS((Tree_tTree t));
  101. struct S_12 {
  102.     union {
  103.         char dummy;
  104.     } U_1;
  105. };
  106. struct S_13 {
  107.     union {
  108.         char dummy;
  109.     } U_1;
  110. };
  111. static void yyExit ARGS(());
  112.  
  113.  
  114. void TreeMod2_WriteLine
  115. # ifdef __STDC__
  116. (Positions_tPosition Line)
  117. # else
  118. (Line)
  119. Positions_tPosition Line;
  120. # endif
  121. {
  122.   if (Line.Line != 0) {
  123.     IO_WriteS(Tree_f, (STRING)"(* line ", 8L);
  124.     Tree_WN((LONGINT)Line.Line);
  125.     IO_WriteS(Tree_f, (STRING)" \"", 2L);
  126.     Tree_WI(Line.File);
  127.     IO_WriteS(Tree_f, (STRING)"\" *)", 4L);
  128.     IO_WriteNl(Tree_f);
  129.   }
  130. }
  131.  
  132. static void yyAbort
  133. # ifdef __STDC__
  134. (CHAR yyFunction[], LONGCARD O_1)
  135. # else
  136. (yyFunction, O_1)
  137. CHAR yyFunction[];
  138. LONGCARD O_1;
  139. # endif
  140. {
  141.   OPEN_ARRAY_LOCALS
  142.  
  143.   ALLOC_OPEN_ARRAYS(O_1 * sizeof(CHAR), 1)
  144.   COPY_OPEN_ARRAY(yyFunction, O_1, CHAR)
  145.   IO_WriteS((System_tFile)IO_StdError, (STRING)"Error: module TreeMod2, routine ", 32L);
  146.   IO_WriteS((System_tFile)IO_StdError, yyFunction, O_1);
  147.   IO_WriteS((System_tFile)IO_StdError, (STRING)" failed", 7L);
  148.   IO_WriteNl((System_tFile)IO_StdError);
  149.   (*TreeMod2_Exit)();
  150.   FREE_OPEN_ARRAYS
  151. }
  152.  
  153. static BOOLEAN yyIsEqual
  154. # ifdef __STDC__
  155. (BYTE yya[], LONGCARD O_3, BYTE yyb[], LONGCARD O_2)
  156. # else
  157. (yya, O_3, yyb, O_2)
  158. BYTE yya[];
  159. LONGCARD O_3;
  160. BYTE yyb[];
  161. LONGCARD O_2;
  162. # endif
  163. {
  164.   INTEGER yyi;
  165.   OPEN_ARRAY_LOCALS
  166.  
  167.   ALLOC_OPEN_ARRAYS(O_2 * sizeof(WORD) + O_3 * sizeof(WORD), 2)
  168.   COPY_OPEN_ARRAY(yyb, O_2, WORD)
  169.   COPY_OPEN_ARRAY(yya, O_3, WORD)
  170.   {
  171.     LONGINT B_1 = 0, B_2 = (INTEGER)(O_3 - 1);
  172.  
  173.     if (B_1 <= B_2)
  174.       for (yyi = B_1;; yyi += 1) {
  175.         if (yya[yyi] != yyb[yyi]) {
  176.           FREE_OPEN_ARRAYS
  177.           return FALSE;
  178.         }
  179.         if (yyi >= B_2) break;
  180.       }
  181.   }
  182.   FREE_OPEN_ARRAYS
  183.   return TRUE;
  184. }
  185.  
  186. void TreeMod2_TreeIO
  187. # ifdef __STDC__
  188. (Tree_tTree t)
  189. # else
  190. (t)
  191. Tree_tTree t;
  192. # endif
  193. {
  194.   struct S_3 yyTempo;
  195.  
  196.   if (t == Tree_NoTree) {
  197.     return;
  198.   }
  199.   if (t->U_1.V_1.Kind == Tree_Ag) {
  200.     {
  201.       register Tree_yAg *W_1 = &t->U_1.V_26.Ag;
  202.  
  203.       IO_WriteS(Tree_f, (STRING)"TYPE yyPtrtTree    = POINTER TO ", 29L);
  204.       Tree_WI(Tree_itTree);
  205.       IO_WriteS(Tree_f, (STRING)";", 1L);
  206.       IO_WriteNl(Tree_f);
  207.       IO_WriteNl(Tree_f);
  208.       IO_WriteS(Tree_f, (STRING)"VAR yyf    : IO.tFile;", 19L);
  209.       IO_WriteNl(Tree_f);
  210.       IO_WriteS(Tree_f, (STRING)"VAR yyLabel    : SHORTCARD;", 24L);
  211.       IO_WriteNl(Tree_f);
  212.       IO_WriteS(Tree_f, (STRING)"VAR yyKind    : SHORTCARD;", 23L);
  213.       IO_WriteNl(Tree_f);
  214.       IO_WriteS(Tree_f, (STRING)"VAR yyc    : CHAR;", 15L);
  215.       IO_WriteNl(Tree_f);
  216.       IO_WriteS(Tree_f, (STRING)"VAR yys    : Strings.tString;", 26L);
  217.       IO_WriteNl(Tree_f);
  218.       IO_WriteNl(Tree_f);
  219.       if (Sets_IsElement(ORD(','), &Tree_Options)) {
  220.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyMark (yyt: ", 23L);
  221.         Tree_WI(Tree_itTree);
  222.         IO_WriteS(Tree_f, (STRING)");", 2L);
  223.         IO_WriteNl(Tree_f);
  224.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  225.         IO_WriteNl(Tree_f);
  226.         IO_WriteS(Tree_f, (STRING)"  LOOP", 6L);
  227.         IO_WriteNl(Tree_f);
  228.         IO_WriteS(Tree_f, (STRING)"   IF yyt = ", 12L);
  229.         Tree_WI(Tree_iNoTree);
  230.         IO_WriteS(Tree_f, (STRING)" THEN RETURN; END;", 18L);
  231.         IO_WriteNl(Tree_f);
  232.         IO_WriteS(Tree_f, (STRING)"   INC (yyt^.yyHead.yyMark);", 28L);
  233.         IO_WriteNl(Tree_f);
  234.         IO_WriteS(Tree_f, (STRING)"   IF yyt^.yyHead.yyMark > 1 THEN RETURN; END;", 46L);
  235.         IO_WriteNl(Tree_f);
  236.         IO_WriteNl(Tree_f);
  237.         IO_WriteS(Tree_f, (STRING)"   CASE yyt^.Kind OF", 20L);
  238.         IO_WriteNl(Tree_f);
  239.         Tree_ForallClasses(W_1->Classes, (Tree_ProcOfT)Mark);
  240.         IO_WriteS(Tree_f, (STRING)"   ELSE RETURN;", 15L);
  241.         IO_WriteNl(Tree_f);
  242.         IO_WriteS(Tree_f, (STRING)"   END;", 7L);
  243.         IO_WriteNl(Tree_f);
  244.         IO_WriteS(Tree_f, (STRING)"  END;", 6L);
  245.         IO_WriteNl(Tree_f);
  246.         IO_WriteS(Tree_f, (STRING)" END yyMark;", 12L);
  247.         IO_WriteNl(Tree_f);
  248.         IO_WriteNl(Tree_f);
  249.       }
  250.       if (Sets_IsElement(ORD(';'), &Tree_Options)) {
  251.         IO_WriteS(Tree_f, (STRING)"CONST yyInitTreeStoreSize    = 32;", 31L);
  252.         IO_WriteNl(Tree_f);
  253.         IO_WriteNl(Tree_f);
  254.         IO_WriteS(Tree_f, (STRING)"VAR yyTreeStoreSize    : LONGINT;", 30L);
  255.         IO_WriteNl(Tree_f);
  256.         IO_WriteS(Tree_f, (STRING)"VAR yyTreeStorePtr    : POINTER TO ARRAY [0..50000] OF ", 52L);
  257.         Tree_WI(Tree_itTree);
  258.         IO_WriteS(Tree_f, (STRING)";", 1L);
  259.         IO_WriteNl(Tree_f);
  260.         IO_WriteS(Tree_f, (STRING)"VAR yyLabelCount    : INTEGER;", 27L);
  261.         IO_WriteNl(Tree_f);
  262.         IO_WriteS(Tree_f, (STRING)"VAR yyRecursionLevel    : SHORTINT;", 32L);
  263.         IO_WriteNl(Tree_f);
  264.         IO_WriteNl(Tree_f);
  265.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyMapToLabel (yyTree: ", 32L);
  266.         Tree_WI(Tree_itTree);
  267.         IO_WriteS(Tree_f, (STRING)"): SHORTCARD;", 13L);
  268.         IO_WriteNl(Tree_f);
  269.         IO_WriteS(Tree_f, (STRING)" VAR yyi    : INTEGER;", 19L);
  270.         IO_WriteNl(Tree_f);
  271.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  272.         IO_WriteNl(Tree_f);
  273.         IO_WriteS(Tree_f, (STRING)"  FOR yyi := 1 TO yyLabelCount DO", 33L);
  274.         IO_WriteNl(Tree_f);
  275.         IO_WriteS(Tree_f, (STRING)"   IF yyTreeStorePtr^[yyi] = yyTree THEN RETURN yyi; END;", 57L);
  276.         IO_WriteNl(Tree_f);
  277.         IO_WriteS(Tree_f, (STRING)"  END;", 6L);
  278.         IO_WriteNl(Tree_f);
  279.         IO_WriteS(Tree_f, (STRING)"  INC (yyLabelCount);", 21L);
  280.         IO_WriteNl(Tree_f);
  281.         IO_WriteS(Tree_f, (STRING)"  IF yyLabelCount = yyTreeStoreSize THEN", 40L);
  282.         IO_WriteNl(Tree_f);
  283.         IO_WriteS(Tree_f, (STRING)"   DynArray.ExtendArray (yyTreeStorePtr, yyTreeStoreSize, SYSTEM.TSIZE (", 72L);
  284.         Tree_WI(Tree_itTree);
  285.         IO_WriteS(Tree_f, (STRING)"));", 3L);
  286.         IO_WriteNl(Tree_f);
  287.         IO_WriteS(Tree_f, (STRING)"  END;", 6L);
  288.         IO_WriteNl(Tree_f);
  289.         IO_WriteS(Tree_f, (STRING)"  yyTreeStorePtr^[yyLabelCount] := yyTree;", 42L);
  290.         IO_WriteNl(Tree_f);
  291.         IO_WriteS(Tree_f, (STRING)"  RETURN yyLabelCount;", 22L);
  292.         IO_WriteNl(Tree_f);
  293.         IO_WriteS(Tree_f, (STRING)" END yyMapToLabel;", 18L);
  294.         IO_WriteNl(Tree_f);
  295.         IO_WriteNl(Tree_f);
  296.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyMapToTree (yyLabel: SHORTCARD): ", 44L);
  297.         Tree_WI(Tree_itTree);
  298.         IO_WriteS(Tree_f, (STRING)";", 1L);
  299.         IO_WriteNl(Tree_f);
  300.         IO_WriteS(Tree_f, (STRING)" BEGIN RETURN yyTreeStorePtr^[yyLabel]; END yyMapToTree;", 56L);
  301.         IO_WriteNl(Tree_f);
  302.         IO_WriteNl(Tree_f);
  303.       }
  304.       if (Sets_IsElement(ORD('w'), &Tree_Options) || Sets_IsElement(ORD('o'), &Tree_Options)) {
  305.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyWriteNl; BEGIN IO.WriteNl (yyf); END yyWriteNl;", 59L);
  306.         IO_WriteNl(Tree_f);
  307.         IO_WriteNl(Tree_f);
  308.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyWriteSelector (yys: ARRAY OF CHAR);", 47L);
  309.         IO_WriteNl(Tree_f);
  310.         IO_WriteS(Tree_f, (STRING)" BEGIN IO.WriteS (yyf, yys); Layout.WriteSpaces (yyf, 15 - INTEGER (HIGH (yys))); IO.WriteS (yyf, ' = '); END yyWriteSelector;", 126L);
  311.         IO_WriteNl(Tree_f);
  312.         IO_WriteNl(Tree_f);
  313.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyWriteHex (VAR yyx: ARRAY OF SYSTEM.BYTE);", 53L);
  314.         IO_WriteNl(Tree_f);
  315.         IO_WriteS(Tree_f, (STRING)" VAR yyi    : INTEGER;", 19L);
  316.         IO_WriteNl(Tree_f);
  317.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  318.         IO_WriteNl(Tree_f);
  319.         IO_WriteS(Tree_f, (STRING)"  FOR yyi := 0 TO INTEGER (HIGH (yyx)) DO", 41L);
  320.         IO_WriteNl(Tree_f);
  321.         IO_WriteS(Tree_f, (STRING)"   IO.WriteN (yyf, ORD (CHAR (yyx [yyi])), 2, 16);", 50L);
  322.         IO_WriteNl(Tree_f);
  323.         IO_WriteS(Tree_f, (STRING)"   IO.WriteC (yyf, ' ');", 24L);
  324.         IO_WriteNl(Tree_f);
  325.         IO_WriteS(Tree_f, (STRING)"  END;", 6L);
  326.         IO_WriteNl(Tree_f);
  327.         IO_WriteS(Tree_f, (STRING)" END yyWriteHex;", 16L);
  328.         IO_WriteNl(Tree_f);
  329.         IO_WriteNl(Tree_f);
  330.       }
  331.       if (Sets_IsElement(ORD('o'), &Tree_Options)) {
  332.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyWriteAdr (yyt: ", 27L);
  333.         Tree_WI(Tree_itTree);
  334.         IO_WriteS(Tree_f, (STRING)");", 2L);
  335.         IO_WriteNl(Tree_f);
  336.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  337.         IO_WriteNl(Tree_f);
  338.         IO_WriteS(Tree_f, (STRING)"  IF yyt = ", 11L);
  339.         Tree_WI(Tree_iNoTree);
  340.         IO_WriteS(Tree_f, (STRING)" THEN", 5L);
  341.         IO_WriteNl(Tree_f);
  342.         IO_WriteS(Tree_f, (STRING)"   IO.WriteS (yyf, '", 20L);
  343.         Tree_WI(Tree_iNoTree);
  344.         IO_WriteS(Tree_f, (STRING)"');", 3L);
  345.         IO_WriteNl(Tree_f);
  346.         IO_WriteS(Tree_f, (STRING)"  ELSE", 6L);
  347.         IO_WriteNl(Tree_f);
  348.         IO_WriteS(Tree_f, (STRING)"   yyWriteHex (yyt);", 20L);
  349.         IO_WriteNl(Tree_f);
  350.         IO_WriteS(Tree_f, (STRING)"  END;", 6L);
  351.         IO_WriteNl(Tree_f);
  352.         IO_WriteS(Tree_f, (STRING)"  yyWriteNl;", 12L);
  353.         IO_WriteNl(Tree_f);
  354.         IO_WriteS(Tree_f, (STRING)" END yyWriteAdr;", 16L);
  355.         IO_WriteNl(Tree_f);
  356.         IO_WriteNl(Tree_f);
  357.         Tree_ForallClasses(W_1->Classes, (Tree_ProcOfT)WriteNode);
  358.         IO_WriteS(Tree_f, (STRING)"PROCEDURE Write", 15L);
  359.         Tree_WI(Tree_iModule);
  360.         IO_WriteS(Tree_f, (STRING)"Node (yyyf: IO.tFile; yyt: ", 27L);
  361.         Tree_WI(Tree_itTree);
  362.         IO_WriteS(Tree_f, (STRING)");", 2L);
  363.         IO_WriteNl(Tree_f);
  364.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  365.         IO_WriteNl(Tree_f);
  366.         IO_WriteS(Tree_f, (STRING)"  yyf := yyyf;", 14L);
  367.         IO_WriteNl(Tree_f);
  368.         IO_WriteS(Tree_f, (STRING)"  IF yyt = ", 11L);
  369.         Tree_WI(Tree_iNoTree);
  370.         IO_WriteS(Tree_f, (STRING)" THEN", 5L);
  371.         IO_WriteNl(Tree_f);
  372.         IO_WriteS(Tree_f, (STRING)"   IO.WriteS (yyf, '", 20L);
  373.         Tree_WI(Tree_iNoTree);
  374.         IO_WriteS(Tree_f, (STRING)"'); yyWriteNl; RETURN;", 22L);
  375.         IO_WriteNl(Tree_f);
  376.         IO_WriteS(Tree_f, (STRING)"  END;", 6L);
  377.         IO_WriteNl(Tree_f);
  378.         IO_WriteNl(Tree_f);
  379.         IO_WriteS(Tree_f, (STRING)"  CASE yyt^.Kind OF", 19L);
  380.         IO_WriteNl(Tree_f);
  381.         Tree_ForallClasses(W_1->Classes, (Tree_ProcOfT)WriteNodeName);
  382.         IO_WriteS(Tree_f, (STRING)"  ELSE", 6L);
  383.         IO_WriteNl(Tree_f);
  384.         IO_WriteS(Tree_f, (STRING)"  END;", 6L);
  385.         IO_WriteNl(Tree_f);
  386.         IO_WriteS(Tree_f, (STRING)" END Write", 10L);
  387.         Tree_WI(Tree_iModule);
  388.         IO_WriteS(Tree_f, (STRING)"Node;", 5L);
  389.         IO_WriteNl(Tree_f);
  390.         IO_WriteNl(Tree_f);
  391.       }
  392.       if (Sets_IsElement(ORD('w'), &Tree_Options)) {
  393.         IO_WriteS(Tree_f, (STRING)"VAR yyIndentLevel    : SHORTINT;", 29L);
  394.         IO_WriteNl(Tree_f);
  395.         IO_WriteNl(Tree_f);
  396.         IO_WriteS(Tree_f, (STRING)"PROCEDURE Write", 15L);
  397.         Tree_WI(Tree_iModule);
  398.         IO_WriteS(Tree_f, (STRING)" (yyyf: IO.tFile; yyt: ", 23L);
  399.         Tree_WI(Tree_itTree);
  400.         IO_WriteS(Tree_f, (STRING)");", 2L);
  401.         IO_WriteNl(Tree_f);
  402.         IO_WriteS(Tree_f, (STRING)" VAR yySaveLevel    : SHORTINT;", 28L);
  403.         IO_WriteNl(Tree_f);
  404.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  405.         IO_WriteNl(Tree_f);
  406.         IO_WriteS(Tree_f, (STRING)"  yyf := yyyf;", 14L);
  407.         IO_WriteNl(Tree_f);
  408.         IO_WriteS(Tree_f, (STRING)"  IF yyRecursionLevel = 0 THEN yyLabelCount := 0; END;", 54L);
  409.         IO_WriteNl(Tree_f);
  410.         IO_WriteS(Tree_f, (STRING)"  INC (yyRecursionLevel);", 25L);
  411.         IO_WriteNl(Tree_f);
  412.         IO_WriteS(Tree_f, (STRING)"  yyMark (yyt);", 15L);
  413.         IO_WriteNl(Tree_f);
  414.         IO_WriteS(Tree_f, (STRING)"  yySaveLevel := yyIndentLevel;", 31L);
  415.         IO_WriteNl(Tree_f);
  416.         IO_WriteS(Tree_f, (STRING)"  yyIndentLevel := 0;", 21L);
  417.         IO_WriteNl(Tree_f);
  418.         IO_WriteS(Tree_f, (STRING)"  yyWrite", 9L);
  419.         Tree_WI(Tree_iModule);
  420.         IO_WriteS(Tree_f, (STRING)" (yyt);", 7L);
  421.         IO_WriteNl(Tree_f);
  422.         IO_WriteS(Tree_f, (STRING)"  yyIndentLevel := yySaveLevel;", 31L);
  423.         IO_WriteNl(Tree_f);
  424.         IO_WriteS(Tree_f, (STRING)"  DEC (yyRecursionLevel);", 25L);
  425.         IO_WriteNl(Tree_f);
  426.         IO_WriteS(Tree_f, (STRING)" END Write", 10L);
  427.         Tree_WI(Tree_iModule);
  428.         IO_WriteS(Tree_f, (STRING)";", 1L);
  429.         IO_WriteNl(Tree_f);
  430.         IO_WriteNl(Tree_f);
  431.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyIndentSelector (yys: ARRAY OF CHAR);", 48L);
  432.         IO_WriteNl(Tree_f);
  433.         IO_WriteS(Tree_f, (STRING)" BEGIN Layout.WriteSpaces (yyf, yyIndentLevel); yyWriteSelector (yys); END yyIndentSelector;", 92L);
  434.         IO_WriteNl(Tree_f);
  435.         IO_WriteNl(Tree_f);
  436.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyIndentSelectorTree (yys: ARRAY OF CHAR; yyt: ", 57L);
  437.         Tree_WI(Tree_itTree);
  438.         IO_WriteS(Tree_f, (STRING)");", 2L);
  439.         IO_WriteNl(Tree_f);
  440.         IO_WriteS(Tree_f, (STRING)" BEGIN yyIndentSelector (yys); write", 36L);
  441.         Tree_WI(Tree_itTree);
  442.         IO_WriteS(Tree_f, (STRING)" (yyt) END yyIndentSelectorTree;", 32L);
  443.         IO_WriteNl(Tree_f);
  444.         IO_WriteNl(Tree_f);
  445.         Tree_ForallClasses(W_1->Classes, (Tree_ProcOfT)WriteAttributes);
  446.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyWrite", 17L);
  447.         Tree_WI(Tree_iModule);
  448.         IO_WriteS(Tree_f, (STRING)" (yyt: ", 7L);
  449.         Tree_WI(Tree_itTree);
  450.         IO_WriteS(Tree_f, (STRING)");", 2L);
  451.         IO_WriteNl(Tree_f);
  452.         IO_WriteS(Tree_f, (STRING)" VAR yyLevel    : SHORTCARD;", 25L);
  453.         IO_WriteNl(Tree_f);
  454.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  455.         IO_WriteNl(Tree_f);
  456.         IO_WriteS(Tree_f, (STRING)"  yyLevel := yyIndentLevel;", 27L);
  457.         IO_WriteNl(Tree_f);
  458.         IO_WriteS(Tree_f, (STRING)"  LOOP", 6L);
  459.         IO_WriteNl(Tree_f);
  460.         IO_WriteS(Tree_f, (STRING)"   IF yyt = ", 12L);
  461.         Tree_WI(Tree_iNoTree);
  462.         IO_WriteS(Tree_f, (STRING)" THEN", 5L);
  463.         IO_WriteNl(Tree_f);
  464.         IO_WriteS(Tree_f, (STRING)"    IO.WriteS (yyf, ' ", 22L);
  465.         Tree_WI(Tree_iNoTree);
  466.         IO_WriteS(Tree_f, (STRING)"'); yyWriteNl; EXIT;", 20L);
  467.         IO_WriteNl(Tree_f);
  468.         IO_WriteS(Tree_f, (STRING)"   ELSIF yyt^.yyHead.yyMark = 0 THEN", 36L);
  469.         IO_WriteNl(Tree_f);
  470.         IO_WriteS(Tree_f, (STRING)"    IO.WriteC (yyf, '^'); IO.WriteI (yyf, yyMapToLabel (yyt), 0); yyWriteNl; EXIT;", 82L);
  471.         IO_WriteNl(Tree_f);
  472.         IO_WriteS(Tree_f, (STRING)"   ELSIF yyt^.yyHead.yyMark > 1 THEN", 36L);
  473.         IO_WriteNl(Tree_f);
  474.         IO_WriteS(Tree_f, (STRING)"    yyWriteNl; IO.WriteN (yyf, yyMapToLabel (yyt), 6, 10); IO.WriteC (yyf, ':');", 80L);
  475.         IO_WriteNl(Tree_f);
  476.         IO_WriteS(Tree_f, (STRING)"    Layout.WriteSpaces (yyf, yyIndentLevel - 7);", 48L);
  477.         IO_WriteNl(Tree_f);
  478.         IO_WriteS(Tree_f, (STRING)"   ELSE", 7L);
  479.         IO_WriteNl(Tree_f);
  480.         IO_WriteS(Tree_f, (STRING)"    IO.WriteC (yyf, ' ');", 25L);
  481.         IO_WriteNl(Tree_f);
  482.         IO_WriteS(Tree_f, (STRING)"   END;", 7L);
  483.         IO_WriteNl(Tree_f);
  484.         IO_WriteS(Tree_f, (STRING)"   yyt^.yyHead.yyMark := 0;", 27L);
  485.         IO_WriteNl(Tree_f);
  486.         IO_WriteS(Tree_f, (STRING)"   INC (yyIndentLevel, 2);", 26L);
  487.         IO_WriteNl(Tree_f);
  488.         IO_WriteNl(Tree_f);
  489.         IO_WriteS(Tree_f, (STRING)"   CASE yyt^.Kind OF", 20L);
  490.         IO_WriteNl(Tree_f);
  491.         Tree_ForallClasses(W_1->Classes, (Tree_ProcOfT)WriteClassName);
  492.         IO_WriteS(Tree_f, (STRING)"   ELSE EXIT;", 13L);
  493.         IO_WriteNl(Tree_f);
  494.         IO_WriteS(Tree_f, (STRING)"   END;", 7L);
  495.         IO_WriteNl(Tree_f);
  496.         IO_WriteS(Tree_f, (STRING)"  END;", 6L);
  497.         IO_WriteNl(Tree_f);
  498.         IO_WriteS(Tree_f, (STRING)"  yyIndentLevel := yyLevel;", 27L);
  499.         IO_WriteNl(Tree_f);
  500.         IO_WriteS(Tree_f, (STRING)" END yyWrite", 12L);
  501.         Tree_WI(Tree_iModule);
  502.         IO_WriteS(Tree_f, (STRING)";", 1L);
  503.         IO_WriteNl(Tree_f);
  504.         IO_WriteNl(Tree_f);
  505.       }
  506.       if (Sets_IsElement(ORD('r'), &Tree_Options)) {
  507.         IO_WriteS(Tree_f, (STRING)"PROCEDURE Read", 14L);
  508.         Tree_WI(Tree_iModule);
  509.         IO_WriteS(Tree_f, (STRING)" (yyyf: IO.tFile): ", 19L);
  510.         Tree_WI(Tree_itTree);
  511.         IO_WriteS(Tree_f, (STRING)";", 1L);
  512.         IO_WriteNl(Tree_f);
  513.         IO_WriteS(Tree_f, (STRING)" VAR yyt    : ", 11L);
  514.         Tree_WI(Tree_itTree);
  515.         IO_WriteS(Tree_f, (STRING)";", 1L);
  516.         IO_WriteNl(Tree_f);
  517.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  518.         IO_WriteNl(Tree_f);
  519.         IO_WriteS(Tree_f, (STRING)"  yyf := yyyf;", 14L);
  520.         IO_WriteNl(Tree_f);
  521.         IO_WriteS(Tree_f, (STRING)"  IF yyRecursionLevel = 0 THEN yyLabelCount := 0; END;", 54L);
  522.         IO_WriteNl(Tree_f);
  523.         IO_WriteS(Tree_f, (STRING)"  INC (yyRecursionLevel);", 25L);
  524.         IO_WriteNl(Tree_f);
  525.         IO_WriteS(Tree_f, (STRING)"  IF NOT yyIsInitialized THEN", 29L);
  526.         IO_WriteNl(Tree_f);
  527.         IO_WriteS(Tree_f, (STRING)"   yyInitKindToIdent; yyIsInitialized := TRUE;", 46L);
  528.         IO_WriteNl(Tree_f);
  529.         IO_WriteS(Tree_f, (STRING)"  END;", 6L);
  530.         IO_WriteNl(Tree_f);
  531.         IO_WriteS(Tree_f, (STRING)"  yyRead", 8L);
  532.         Tree_WI(Tree_iModule);
  533.         IO_WriteS(Tree_f, (STRING)" (SYSTEM.ADR (yyt));", 20L);
  534.         IO_WriteNl(Tree_f);
  535.         IO_WriteS(Tree_f, (STRING)"  DEC (yyRecursionLevel);", 25L);
  536.         IO_WriteNl(Tree_f);
  537.         IO_WriteS(Tree_f, (STRING)"  RETURN yyt;", 13L);
  538.         IO_WriteNl(Tree_f);
  539.         IO_WriteS(Tree_f, (STRING)" END Read", 9L);
  540.         Tree_WI(Tree_iModule);
  541.         IO_WriteS(Tree_f, (STRING)";", 1L);
  542.         IO_WriteNl(Tree_f);
  543.         IO_WriteNl(Tree_f);
  544.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyRead", 16L);
  545.         Tree_WI(Tree_iModule);
  546.         IO_WriteS(Tree_f, (STRING)" (yyt: yyPtrtTree);", 19L);
  547.         IO_WriteNl(Tree_f);
  548.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  549.         IO_WriteNl(Tree_f);
  550.         IO_WriteS(Tree_f, (STRING)"  LOOP", 6L);
  551.         IO_WriteNl(Tree_f);
  552.         IO_WriteS(Tree_f, (STRING)"   CASE IO.ReadC (yyf) OF", 25L);
  553.         IO_WriteNl(Tree_f);
  554.         IO_WriteS(Tree_f, (STRING)"   | '^': yyLabel := IO.ReadI (yyf); yyReadNl; yyt^ := yyMapToTree (yyLabel); RETURN;", 85L);
  555.         IO_WriteNl(Tree_f);
  556.         IO_WriteS(Tree_f, (STRING)"   | 12C, '0': yyLabel := IO.ReadI (yyf); yyc := IO.ReadC (yyf);", 64L);
  557.         IO_WriteNl(Tree_f);
  558.         IO_WriteS(Tree_f, (STRING)"    Layout.SkipSpaces (yyf); Strings.ReadL (yyf, yys);", 54L);
  559.         IO_WriteNl(Tree_f);
  560.         IO_WriteS(Tree_f, (STRING)"    yyKind := yyMapToKind (yys); yyt^ := Make", 45L);
  561.         Tree_WI(Tree_iMain);
  562.         IO_WriteS(Tree_f, (STRING)" (yyKind);", 10L);
  563.         IO_WriteNl(Tree_f);
  564.         IO_WriteS(Tree_f, (STRING)"    IF yyLabel # yyMapToLabel (yyt^) THEN IO.WriteS (IO.StdError, '", 67L);
  565.         Tree_WI(Tree_iModule);
  566.         IO_WriteS(Tree_f, (STRING)": error in Read", 15L);
  567.         Tree_WI(Tree_iModule);
  568.         IO_WriteS(Tree_f, (STRING)"'); IO.WriteNl (IO.StdError); yyExit; END;", 42L);
  569.         IO_WriteNl(Tree_f);
  570.         IO_WriteS(Tree_f, (STRING)"   ELSE", 7L);
  571.         IO_WriteNl(Tree_f);
  572.         IO_WriteS(Tree_f, (STRING)"    Layout.SkipSpaces (yyf); Strings.ReadL (yyf, yys);", 54L);
  573.         IO_WriteNl(Tree_f);
  574.         IO_WriteS(Tree_f, (STRING)"    yyKind := yyMapToKind (yys);", 32L);
  575.         IO_WriteNl(Tree_f);
  576.         IO_WriteS(Tree_f, (STRING)"    IF yyKind = 0 THEN yyt^ := ", 31L);
  577.         Tree_WI(Tree_iNoTree);
  578.         IO_WriteS(Tree_f, (STRING)"; RETURN; END;", 14L);
  579.         IO_WriteNl(Tree_f);
  580.         IO_WriteS(Tree_f, (STRING)"    yyt^ := Make", 16L);
  581.         Tree_WI(Tree_iMain);
  582.         IO_WriteS(Tree_f, (STRING)" (yyKind);", 10L);
  583.         IO_WriteNl(Tree_f);
  584.         IO_WriteS(Tree_f, (STRING)"   END;", 7L);
  585.         IO_WriteNl(Tree_f);
  586.         IO_WriteNl(Tree_f);
  587.         IO_WriteS(Tree_f, (STRING)"   CASE yyKind OF", 17L);
  588.         IO_WriteNl(Tree_f);
  589.         Tree_ForallClasses(W_1->Classes, (Tree_ProcOfT)ReadAttributes);
  590.         IO_WriteS(Tree_f, (STRING)"   ELSE RETURN;", 15L);
  591.         IO_WriteNl(Tree_f);
  592.         IO_WriteS(Tree_f, (STRING)"   END;", 7L);
  593.         IO_WriteNl(Tree_f);
  594.         IO_WriteS(Tree_f, (STRING)"  END;", 6L);
  595.         IO_WriteNl(Tree_f);
  596.         IO_WriteS(Tree_f, (STRING)" END yyRead", 11L);
  597.         Tree_WI(Tree_iModule);
  598.         IO_WriteS(Tree_f, (STRING)";", 1L);
  599.         IO_WriteNl(Tree_f);
  600.         IO_WriteNl(Tree_f);
  601.         IO_WriteS(Tree_f, (STRING)"VAR yyKindToIdent    : ARRAY [0..", 30L);
  602.         Tree_WN(Tree_ClassCount);
  603.         IO_WriteS(Tree_f, (STRING)"] OF Idents.tIdent;", 19L);
  604.         IO_WriteNl(Tree_f);
  605.         IO_WriteS(Tree_f, (STRING)"VAR yyIsInitialized    : BOOLEAN;", 30L);
  606.         IO_WriteNl(Tree_f);
  607.         IO_WriteNl(Tree_f);
  608.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyMapToKind (VAR yys: Strings.tString): SHORTCARD;", 60L);
  609.         IO_WriteNl(Tree_f);
  610.         IO_WriteS(Tree_f, (STRING)" VAR yyi    : Idents.tIdent;", 25L);
  611.         IO_WriteNl(Tree_f);
  612.         IO_WriteS(Tree_f, (STRING)" VAR yyk    : SHORTCARD;", 21L);
  613.         IO_WriteNl(Tree_f);
  614.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  615.         IO_WriteNl(Tree_f);
  616.         IO_WriteS(Tree_f, (STRING)"  yyi := Idents.MakeIdent (yys);", 32L);
  617.         IO_WriteNl(Tree_f);
  618.         IO_WriteS(Tree_f, (STRING)"  FOR yyk := 0 TO ", 18L);
  619.         Tree_WN(Tree_ClassCount);
  620.         IO_WriteS(Tree_f, (STRING)" DO", 3L);
  621.         IO_WriteNl(Tree_f);
  622.         IO_WriteS(Tree_f, (STRING)"   IF yyKindToIdent [yyk] = yyi THEN RETURN yyk; END;", 53L);
  623.         IO_WriteNl(Tree_f);
  624.         IO_WriteS(Tree_f, (STRING)"  END;", 6L);
  625.         IO_WriteNl(Tree_f);
  626.         IO_WriteS(Tree_f, (STRING)"  RETURN 0;", 11L);
  627.         IO_WriteNl(Tree_f);
  628.         IO_WriteS(Tree_f, (STRING)" END yyMapToKind;", 17L);
  629.         IO_WriteNl(Tree_f);
  630.         IO_WriteNl(Tree_f);
  631.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyInitKindToIdent2 (yya: ARRAY OF CHAR; yyKind: SHORTCARD);", 69L);
  632.         IO_WriteNl(Tree_f);
  633.         IO_WriteS(Tree_f, (STRING)" VAR yys    : Strings.tString;", 27L);
  634.         IO_WriteNl(Tree_f);
  635.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  636.         IO_WriteNl(Tree_f);
  637.         IO_WriteS(Tree_f, (STRING)"  Strings.ArrayToString (yya, yys);", 35L);
  638.         IO_WriteNl(Tree_f);
  639.         IO_WriteS(Tree_f, (STRING)"  yyKindToIdent [yyKind] := Idents.MakeIdent (yys);", 51L);
  640.         IO_WriteNl(Tree_f);
  641.         IO_WriteS(Tree_f, (STRING)" END yyInitKindToIdent2;", 24L);
  642.         IO_WriteNl(Tree_f);
  643.         IO_WriteNl(Tree_f);
  644.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyInitKindToIdent;", 28L);
  645.         IO_WriteNl(Tree_f);
  646.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  647.         IO_WriteNl(Tree_f);
  648.         IO_WriteS(Tree_f, (STRING)"  yyInitKindToIdent2 ('", 23L);
  649.         Tree_WI(Tree_iNoTree);
  650.         IO_WriteS(Tree_f, (STRING)"', 0);", 6L);
  651.         IO_WriteNl(Tree_f);
  652.         Tree_ForallClasses(W_1->Classes, (Tree_ProcOfT)InitKindToIdent);
  653.         IO_WriteS(Tree_f, (STRING)" END yyInitKindToIdent;", 23L);
  654.         IO_WriteNl(Tree_f);
  655.         IO_WriteNl(Tree_f);
  656.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyReadNl; BEGIN IO.ReadNl (yyf); END yyReadNl;", 56L);
  657.         IO_WriteNl(Tree_f);
  658.         IO_WriteNl(Tree_f);
  659.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyReadIdent (): Idents.tIdent;", 40L);
  660.         IO_WriteNl(Tree_f);
  661.         IO_WriteS(Tree_f, (STRING)" VAR yys    : Strings.tString;", 27L);
  662.         IO_WriteNl(Tree_f);
  663.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  664.         IO_WriteNl(Tree_f);
  665.         IO_WriteS(Tree_f, (STRING)"  Strings.ReadL (yyf, yys);", 27L);
  666.         IO_WriteNl(Tree_f);
  667.         IO_WriteS(Tree_f, (STRING)"  IO.UnRead (yyf);", 18L);
  668.         IO_WriteNl(Tree_f);
  669.         IO_WriteS(Tree_f, (STRING)"  RETURN Idents.MakeIdent (yys);", 32L);
  670.         IO_WriteNl(Tree_f);
  671.         IO_WriteS(Tree_f, (STRING)" END yyReadIdent;", 17L);
  672.         IO_WriteNl(Tree_f);
  673.         IO_WriteNl(Tree_f);
  674.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyReadHex (VAR yyx: ARRAY OF SYSTEM.BYTE);", 52L);
  675.         IO_WriteNl(Tree_f);
  676.         IO_WriteS(Tree_f, (STRING)" VAR yyi    : INTEGER;", 19L);
  677.         IO_WriteNl(Tree_f);
  678.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  679.         IO_WriteNl(Tree_f);
  680.         IO_WriteS(Tree_f, (STRING)"  FOR yyi := 0 TO INTEGER (HIGH (yyx)) DO", 41L);
  681.         IO_WriteNl(Tree_f);
  682.         IO_WriteS(Tree_f, (STRING)"   yyx [yyi] := SYSTEM.BYTE (CHR (CARDINAL (IO.ReadN (yyf, 16))));", 66L);
  683.         IO_WriteNl(Tree_f);
  684.         IO_WriteS(Tree_f, (STRING)"  END;", 6L);
  685.         IO_WriteNl(Tree_f);
  686.         IO_WriteS(Tree_f, (STRING)" END yyReadHex;", 15L);
  687.         IO_WriteNl(Tree_f);
  688.         IO_WriteNl(Tree_f);
  689.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yySkip;", 17L);
  690.         IO_WriteNl(Tree_f);
  691.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  692.         IO_WriteNl(Tree_f);
  693.         IO_WriteS(Tree_f, (STRING)"  REPEAT UNTIL IO.ReadC (yyf) = '='; yyc := IO.ReadC (yyf);", 59L);
  694.         IO_WriteNl(Tree_f);
  695.         IO_WriteS(Tree_f, (STRING)" END yySkip;", 12L);
  696.         IO_WriteNl(Tree_f);
  697.         IO_WriteNl(Tree_f);
  698.       }
  699.       IO_WriteS(Tree_f, (STRING)"CONST yyNil    = 374C;", 19L);
  700.       IO_WriteNl(Tree_f);
  701.       IO_WriteS(Tree_f, (STRING)"CONST yyNoLabel    = 375C;", 23L);
  702.       IO_WriteNl(Tree_f);
  703.       IO_WriteS(Tree_f, (STRING)"CONST yyLabelDef    = 376C;", 24L);
  704.       IO_WriteNl(Tree_f);
  705.       IO_WriteS(Tree_f, (STRING)"CONST yyLabelUse    = 377C;", 24L);
  706.       IO_WriteNl(Tree_f);
  707.       IO_WriteNl(Tree_f);
  708.       if (Sets_IsElement(ORD('p'), &Tree_Options)) {
  709.         IO_WriteS(Tree_f, (STRING)"PROCEDURE Put", 13L);
  710.         Tree_WI(Tree_iModule);
  711.         IO_WriteS(Tree_f, (STRING)" (yyyf: IO.tFile; yyt: ", 23L);
  712.         Tree_WI(Tree_itTree);
  713.         IO_WriteS(Tree_f, (STRING)");", 2L);
  714.         IO_WriteNl(Tree_f);
  715.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  716.         IO_WriteNl(Tree_f);
  717.         IO_WriteS(Tree_f, (STRING)"  yyf := yyyf;", 14L);
  718.         IO_WriteNl(Tree_f);
  719.         IO_WriteS(Tree_f, (STRING)"  IF yyRecursionLevel = 0 THEN yyLabelCount := 0; END;", 54L);
  720.         IO_WriteNl(Tree_f);
  721.         IO_WriteS(Tree_f, (STRING)"  INC (yyRecursionLevel);", 25L);
  722.         IO_WriteNl(Tree_f);
  723.         IO_WriteS(Tree_f, (STRING)"  yyMark (yyt);", 15L);
  724.         IO_WriteNl(Tree_f);
  725.         IO_WriteS(Tree_f, (STRING)"  yyPut", 7L);
  726.         Tree_WI(Tree_iModule);
  727.         IO_WriteS(Tree_f, (STRING)" (yyt);", 7L);
  728.         IO_WriteNl(Tree_f);
  729.         IO_WriteS(Tree_f, (STRING)"  DEC (yyRecursionLevel);", 25L);
  730.         IO_WriteNl(Tree_f);
  731.         IO_WriteS(Tree_f, (STRING)" END Put", 8L);
  732.         Tree_WI(Tree_iModule);
  733.         IO_WriteS(Tree_f, (STRING)";", 1L);
  734.         IO_WriteNl(Tree_f);
  735.         IO_WriteNl(Tree_f);
  736.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyPut", 15L);
  737.         Tree_WI(Tree_iModule);
  738.         IO_WriteS(Tree_f, (STRING)" (yyt: ", 7L);
  739.         Tree_WI(Tree_itTree);
  740.         IO_WriteS(Tree_f, (STRING)");", 2L);
  741.         IO_WriteNl(Tree_f);
  742.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  743.         IO_WriteNl(Tree_f);
  744.         IO_WriteS(Tree_f, (STRING)"  LOOP", 6L);
  745.         IO_WriteNl(Tree_f);
  746.         IO_WriteS(Tree_f, (STRING)"   IF yyt = ", 12L);
  747.         Tree_WI(Tree_iNoTree);
  748.         IO_WriteS(Tree_f, (STRING)" THEN", 5L);
  749.         IO_WriteNl(Tree_f);
  750.         IO_WriteS(Tree_f, (STRING)"    IO.WriteC (yyf, yyNil); RETURN;", 35L);
  751.         IO_WriteNl(Tree_f);
  752.         IO_WriteS(Tree_f, (STRING)"   ELSIF yyt^.yyHead.yyMark = 0 THEN", 36L);
  753.         IO_WriteNl(Tree_f);
  754.         IO_WriteS(Tree_f, (STRING)"    IO.WriteC (yyf, yyLabelUse); yyLabel := yyMapToLabel (yyt); yyPut (yyLabel);", 80L);
  755.         IO_WriteNl(Tree_f);
  756.         IO_WriteS(Tree_f, (STRING)"    RETURN;", 11L);
  757.         IO_WriteNl(Tree_f);
  758.         IO_WriteS(Tree_f, (STRING)"   ELSIF yyt^.yyHead.yyMark > 1 THEN", 36L);
  759.         IO_WriteNl(Tree_f);
  760.         IO_WriteS(Tree_f, (STRING)"    IO.WriteC (yyf, yyLabelDef); yyLabel := yyMapToLabel (yyt); yyPut (yyLabel);", 80L);
  761.         IO_WriteNl(Tree_f);
  762.         if (Tree_ClassCount > 251) {
  763.           IO_WriteS(Tree_f, (STRING)"    yyPut (yyt^.Kind);", 22L);
  764.           IO_WriteNl(Tree_f);
  765.           IO_WriteS(Tree_f, (STRING)"   ELSIF yyt^.Kind > 251 THEN", 29L);
  766.           IO_WriteNl(Tree_f);
  767.           IO_WriteS(Tree_f, (STRING)"    IO.WriteC (yyf, yyNoLabel); yyPut (yyt^.Kind);", 50L);
  768.           IO_WriteNl(Tree_f);
  769.         } else {
  770.           IO_WriteS(Tree_f, (STRING)"    IO.WriteC (yyf, CHR (yyt^.Kind));", 37L);
  771.           IO_WriteNl(Tree_f);
  772.         }
  773.         IO_WriteS(Tree_f, (STRING)"   ELSE", 7L);
  774.         IO_WriteNl(Tree_f);
  775.         IO_WriteS(Tree_f, (STRING)"    IO.WriteC (yyf, CHR (yyt^.Kind));", 37L);
  776.         IO_WriteNl(Tree_f);
  777.         IO_WriteS(Tree_f, (STRING)"   END;", 7L);
  778.         IO_WriteNl(Tree_f);
  779.         IO_WriteS(Tree_f, (STRING)"   yyt^.yyHead.yyMark := 0;", 27L);
  780.         IO_WriteNl(Tree_f);
  781.         IO_WriteNl(Tree_f);
  782.         IO_WriteS(Tree_f, (STRING)"   CASE yyt^.Kind OF", 20L);
  783.         IO_WriteNl(Tree_f);
  784.         Tree_ForallClasses(W_1->Classes, (Tree_ProcOfT)PutAttributes);
  785.         IO_WriteS(Tree_f, (STRING)"   ELSE RETURN;", 15L);
  786.         IO_WriteNl(Tree_f);
  787.         IO_WriteS(Tree_f, (STRING)"   END;", 7L);
  788.         IO_WriteNl(Tree_f);
  789.         IO_WriteS(Tree_f, (STRING)"  END;", 6L);
  790.         IO_WriteNl(Tree_f);
  791.         IO_WriteS(Tree_f, (STRING)" END yyPut", 10L);
  792.         Tree_WI(Tree_iModule);
  793.         IO_WriteS(Tree_f, (STRING)";", 1L);
  794.         IO_WriteNl(Tree_f);
  795.         IO_WriteNl(Tree_f);
  796.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyPut (VAR yyx: ARRAY OF SYSTEM.BYTE);", 48L);
  797.         IO_WriteNl(Tree_f);
  798.         IO_WriteS(Tree_f, (STRING)" VAR yyi    : INTEGER;", 19L);
  799.         IO_WriteNl(Tree_f);
  800.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  801.         IO_WriteNl(Tree_f);
  802.         IO_WriteS(Tree_f, (STRING)"  yyi := IO.Write (yyf, SYSTEM.ADR (yyx), INTEGER (HIGH (yyx)) + 1);", 68L);
  803.         IO_WriteNl(Tree_f);
  804.         IO_WriteS(Tree_f, (STRING)" END yyPut;", 11L);
  805.         IO_WriteNl(Tree_f);
  806.         IO_WriteNl(Tree_f);
  807.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyPutIdent (yyi: Idents.tIdent);", 42L);
  808.         IO_WriteNl(Tree_f);
  809.         IO_WriteS(Tree_f, (STRING)" VAR yys    : Strings.tString;", 27L);
  810.         IO_WriteNl(Tree_f);
  811.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  812.         IO_WriteNl(Tree_f);
  813.         IO_WriteS(Tree_f, (STRING)"  Idents.GetString (yyi, yys);", 30L);
  814.         IO_WriteNl(Tree_f);
  815.         IO_WriteS(Tree_f, (STRING)"  Strings.WriteL (yyf, yys);", 28L);
  816.         IO_WriteNl(Tree_f);
  817.         IO_WriteS(Tree_f, (STRING)" END yyPutIdent;", 16L);
  818.         IO_WriteNl(Tree_f);
  819.         IO_WriteNl(Tree_f);
  820.       }
  821.       if (Sets_IsElement(ORD('g'), &Tree_Options)) {
  822.         IO_WriteS(Tree_f, (STRING)"PROCEDURE Get", 13L);
  823.         Tree_WI(Tree_iModule);
  824.         IO_WriteS(Tree_f, (STRING)" (yyyf: IO.tFile): ", 19L);
  825.         Tree_WI(Tree_itTree);
  826.         IO_WriteS(Tree_f, (STRING)";", 1L);
  827.         IO_WriteNl(Tree_f);
  828.         IO_WriteS(Tree_f, (STRING)" VAR yyt    : ", 11L);
  829.         Tree_WI(Tree_itTree);
  830.         IO_WriteS(Tree_f, (STRING)";", 1L);
  831.         IO_WriteNl(Tree_f);
  832.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  833.         IO_WriteNl(Tree_f);
  834.         IO_WriteS(Tree_f, (STRING)"  yyf := yyyf;", 14L);
  835.         IO_WriteNl(Tree_f);
  836.         IO_WriteS(Tree_f, (STRING)"  IF yyRecursionLevel = 0 THEN yyLabelCount := 0; END;", 54L);
  837.         IO_WriteNl(Tree_f);
  838.         IO_WriteS(Tree_f, (STRING)"  INC (yyRecursionLevel);", 25L);
  839.         IO_WriteNl(Tree_f);
  840.         IO_WriteS(Tree_f, (STRING)"  yyGet", 7L);
  841.         Tree_WI(Tree_iModule);
  842.         IO_WriteS(Tree_f, (STRING)" (SYSTEM.ADR (yyt));", 20L);
  843.         IO_WriteNl(Tree_f);
  844.         IO_WriteS(Tree_f, (STRING)"  DEC (yyRecursionLevel);", 25L);
  845.         IO_WriteNl(Tree_f);
  846.         IO_WriteS(Tree_f, (STRING)"  RETURN yyt;", 13L);
  847.         IO_WriteNl(Tree_f);
  848.         IO_WriteS(Tree_f, (STRING)" END Get", 8L);
  849.         Tree_WI(Tree_iModule);
  850.         IO_WriteS(Tree_f, (STRING)";", 1L);
  851.         IO_WriteNl(Tree_f);
  852.         IO_WriteNl(Tree_f);
  853.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyGet", 15L);
  854.         Tree_WI(Tree_iModule);
  855.         IO_WriteS(Tree_f, (STRING)" (yyt: yyPtrtTree);", 19L);
  856.         IO_WriteNl(Tree_f);
  857.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  858.         IO_WriteNl(Tree_f);
  859.         IO_WriteS(Tree_f, (STRING)"  LOOP", 6L);
  860.         IO_WriteNl(Tree_f);
  861.         IO_WriteS(Tree_f, (STRING)"   yyc := IO.ReadC (yyf);", 25L);
  862.         IO_WriteNl(Tree_f);
  863.         IO_WriteS(Tree_f, (STRING)"   CASE yyc OF", 14L);
  864.         IO_WriteNl(Tree_f);
  865.         IO_WriteS(Tree_f, (STRING)"   | yyNil    : yyt^ := ", 21L);
  866.         Tree_WI(Tree_iNoTree);
  867.         IO_WriteS(Tree_f, (STRING)"; RETURN;", 9L);
  868.         IO_WriteNl(Tree_f);
  869.         IO_WriteS(Tree_f, (STRING)"   | yyLabelUse    : yyGet (yyLabel); yyt^ := yyMapToTree (yyLabel); RETURN;", 73L);
  870.         IO_WriteNl(Tree_f);
  871.         IO_WriteS(Tree_f, (STRING)"   | yyLabelDef    : yyGet (yyLabel);", 34L);
  872.         if (Tree_ClassCount > 251) {
  873.           IO_WriteS(Tree_f, (STRING)" yyGet (yyKind);", 16L);
  874.         } else {
  875.           IO_WriteS(Tree_f, (STRING)" yyKind := ORD (IO.ReadC (yyf));", 32L);
  876.         }
  877.         IO_WriteS(Tree_f, (STRING)" yyt^ := Make", 13L);
  878.         Tree_WI(Tree_iMain);
  879.         IO_WriteS(Tree_f, (STRING)" (yyKind);", 10L);
  880.         IO_WriteNl(Tree_f);
  881.         IO_WriteS(Tree_f, (STRING)"    IF yyLabel # yyMapToLabel (yyt^) THEN IO.WriteS (IO.StdError, '", 67L);
  882.         Tree_WI(Tree_iModule);
  883.         IO_WriteS(Tree_f, (STRING)": error in Get", 14L);
  884.         Tree_WI(Tree_iModule);
  885.         IO_WriteS(Tree_f, (STRING)"'); IO.WriteNl (IO.StdError); yyExit; END;", 42L);
  886.         IO_WriteNl(Tree_f);
  887.         if (Tree_ClassCount > 251) {
  888.           IO_WriteS(Tree_f, (STRING)"   | yyNoLabel    : yyGet (yyKind); yyt^ := Make", 45L);
  889.           Tree_WI(Tree_iMain);
  890.           IO_WriteS(Tree_f, (STRING)" (yyKind);", 10L);
  891.           IO_WriteNl(Tree_f);
  892.         }
  893.         IO_WriteS(Tree_f, (STRING)"   ELSE yyKind := ORD (yyc); yyt^ := Make", 41L);
  894.         Tree_WI(Tree_iMain);
  895.         IO_WriteS(Tree_f, (STRING)" (yyKind);", 10L);
  896.         IO_WriteNl(Tree_f);
  897.         IO_WriteS(Tree_f, (STRING)"   END;", 7L);
  898.         IO_WriteNl(Tree_f);
  899.         IO_WriteNl(Tree_f);
  900.         IO_WriteS(Tree_f, (STRING)"   CASE yyKind OF", 17L);
  901.         IO_WriteNl(Tree_f);
  902.         Tree_ForallClasses(W_1->Classes, (Tree_ProcOfT)GetAttributes);
  903.         IO_WriteS(Tree_f, (STRING)"   ELSE RETURN;", 15L);
  904.         IO_WriteNl(Tree_f);
  905.         IO_WriteS(Tree_f, (STRING)"   END;", 7L);
  906.         IO_WriteNl(Tree_f);
  907.         IO_WriteS(Tree_f, (STRING)"  END;", 6L);
  908.         IO_WriteNl(Tree_f);
  909.         IO_WriteS(Tree_f, (STRING)" END yyGet", 10L);
  910.         Tree_WI(Tree_iModule);
  911.         IO_WriteS(Tree_f, (STRING)";", 1L);
  912.         IO_WriteNl(Tree_f);
  913.         IO_WriteNl(Tree_f);
  914.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyGet (VAR yyx: ARRAY OF SYSTEM.BYTE);", 48L);
  915.         IO_WriteNl(Tree_f);
  916.         IO_WriteS(Tree_f, (STRING)" VAR yyi    : INTEGER;", 19L);
  917.         IO_WriteNl(Tree_f);
  918.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  919.         IO_WriteNl(Tree_f);
  920.         IO_WriteS(Tree_f, (STRING)"  yyi := IO.Read (yyf, SYSTEM.ADR (yyx), INTEGER (HIGH (yyx)) + 1);", 67L);
  921.         IO_WriteNl(Tree_f);
  922.         IO_WriteS(Tree_f, (STRING)" END yyGet;", 11L);
  923.         IO_WriteNl(Tree_f);
  924.         IO_WriteNl(Tree_f);
  925.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyGetIdent (VAR yyi: Idents.tIdent);", 46L);
  926.         IO_WriteNl(Tree_f);
  927.         IO_WriteS(Tree_f, (STRING)" VAR yys    : Strings.tString;", 27L);
  928.         IO_WriteNl(Tree_f);
  929.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  930.         IO_WriteNl(Tree_f);
  931.         IO_WriteS(Tree_f, (STRING)"  Strings.ReadL (yyf, yys);", 27L);
  932.         IO_WriteNl(Tree_f);
  933.         IO_WriteS(Tree_f, (STRING)"  yyi := Idents.MakeIdent (yys);", 32L);
  934.         IO_WriteNl(Tree_f);
  935.         IO_WriteS(Tree_f, (STRING)" END yyGetIdent;", 16L);
  936.         IO_WriteNl(Tree_f);
  937.         IO_WriteNl(Tree_f);
  938.       }
  939.       return;
  940.     }
  941.   }
  942. }
  943.  
  944. static void WriteNodeName
  945. # ifdef __STDC__
  946. (Tree_tTree t)
  947. # else
  948. (t)
  949. Tree_tTree t;
  950. # endif
  951. {
  952.   struct S_4 yyTempo;
  953.  
  954.   if (t == Tree_NoTree) {
  955.     return;
  956.   }
  957.   if (t->U_1.V_1.Kind == Tree_Class) {
  958.     {
  959.       register Tree_yClass *W_2 = &t->U_1.V_5.Class;
  960.  
  961.       if ((Tree_NoCodeClass & W_2->Properties) == 0X0L) {
  962.         IO_WriteS(Tree_f, (STRING)"| ", 2L);
  963.         Tree_WI(W_2->Name);
  964.         IO_WriteS(Tree_f, (STRING)": IO.WriteS (yyf, '", 19L);
  965.         Tree_WI(W_2->Name);
  966.         IO_WriteS(Tree_f, (STRING)"'); yyWriteNl;", 14L);
  967.         if (((SET_ELEM(Tree_HasChildren) | SET_ELEM(Tree_HasAttributes)) & W_2->Properties) != 0X0L) {
  968.           IO_WriteS(Tree_f, (STRING)" yWriteNode", 11L);
  969.           Tree_WI(W_2->Name);
  970.           IO_WriteS(Tree_f, (STRING)" (yyt);", 7L);
  971.         }
  972.         IO_WriteNl(Tree_f);
  973.       }
  974.       return;
  975.     }
  976.   }
  977. }
  978.  
  979. static void WriteNode
  980. # ifdef __STDC__
  981. (Tree_tTree t)
  982. # else
  983. (t)
  984. Tree_tTree t;
  985. # endif
  986. {
  987.   struct S_5 yyTempo;
  988.  
  989.   if (t == Tree_NoTree) {
  990.     return;
  991.   }
  992.   if (t->U_1.V_1.Kind == Tree_Class) {
  993.     {
  994.       register Tree_yClass *W_3 = &t->U_1.V_5.Class;
  995.  
  996.       if ((Tree_NoCodeClass & W_3->Properties) == 0X0L && ((SET_ELEM(Tree_HasChildren) | SET_ELEM(Tree_HasAttributes)) & W_3->Properties) != 0X0L) {
  997.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yWriteNode", 20L);
  998.         Tree_WI(W_3->Name);
  999.         IO_WriteS(Tree_f, (STRING)" (yyt: ", 7L);
  1000.         Tree_WI(Tree_itTree);
  1001.         IO_WriteS(Tree_f, (STRING)");", 2L);
  1002.         IO_WriteNl(Tree_f);
  1003.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  1004.         IO_WriteNl(Tree_f);
  1005.         if (W_3->BaseClass->U_1.V_1.Kind == Tree_Class && ((SET_ELEM(Tree_HasChildren) | SET_ELEM(Tree_HasAttributes)) & W_3->BaseClass->U_1.V_5.Class.Properties) != 0X0L) {
  1006.           IO_WriteS(Tree_f, (STRING)"  yWriteNode", 12L);
  1007.           Tree_WI(W_3->BaseClass->U_1.V_5.Class.Name);
  1008.           IO_WriteS(Tree_f, (STRING)" (yyt); ", 8L);
  1009.           IO_WriteNl(Tree_f);
  1010.         }
  1011.         iClassName = W_3->Name;
  1012.         Tree_ForallAttributes(W_3->Attributes, (Tree_ProcOfT)WriteNode);
  1013.         IO_WriteS(Tree_f, (STRING)" END yWriteNode", 15L);
  1014.         Tree_WI(W_3->Name);
  1015.         IO_WriteS(Tree_f, (STRING)";", 1L);
  1016.         IO_WriteNl(Tree_f);
  1017.         IO_WriteNl(Tree_f);
  1018.       }
  1019.       return;
  1020.     }
  1021.   }
  1022.   if (t->U_1.V_1.Kind == Tree_Child) {
  1023.     {
  1024.       register Tree_yChild *W_4 = &t->U_1.V_9.Child;
  1025.  
  1026.       IO_WriteS(Tree_f, (STRING)"  yyWriteSelector ('", 20L);
  1027.       Tree_WI(W_4->Name);
  1028.       IO_WriteS(Tree_f, (STRING)"');", 3L);
  1029.       IO_WriteS(Tree_f, (STRING)" yyWriteAdr (yyt^.", 18L);
  1030.       Tree_WI(iClassName);
  1031.       IO_WriteS(Tree_f, (STRING)".", 1L);
  1032.       Tree_WI(W_4->Name);
  1033.       IO_WriteS(Tree_f, (STRING)");", 2L);
  1034.       IO_WriteNl(Tree_f);
  1035.       return;
  1036.     }
  1037.   }
  1038.   if (t->U_1.V_1.Kind == Tree_Attribute) {
  1039.     {
  1040.       register Tree_yAttribute *W_5 = &t->U_1.V_10.Attribute;
  1041.  
  1042.       if ((Tree_NoCodeAttr & W_5->Properties) == 0X0L) {
  1043.         IO_WriteS(Tree_f, (STRING)"  yyWriteSelector ('", 20L);
  1044.         Tree_WI(W_5->Name);
  1045.         IO_WriteS(Tree_f, (STRING)"'); write", 9L);
  1046.         Tree_WI(W_5->Type);
  1047.         IO_WriteS(Tree_f, (STRING)" (yyt^.", 7L);
  1048.         Tree_WI(iClassName);
  1049.         IO_WriteS(Tree_f, (STRING)".", 1L);
  1050.         Tree_WI(W_5->Name);
  1051.         IO_WriteS(Tree_f, (STRING)") yyWriteNl;", 12L);
  1052.         IO_WriteNl(Tree_f);
  1053.       }
  1054.       return;
  1055.     }
  1056.   }
  1057. }
  1058.  
  1059. static void Mark
  1060. # ifdef __STDC__
  1061. (Tree_tTree t)
  1062. # else
  1063. (t)
  1064. Tree_tTree t;
  1065. # endif
  1066. {
  1067.   struct S_6 yyTempo;
  1068.  
  1069.   if (t == Tree_NoTree) {
  1070.     return;
  1071.   }
  1072.   if (t->U_1.V_1.Kind == Tree_Class) {
  1073.     {
  1074.       register Tree_yClass *W_6 = &t->U_1.V_5.Class;
  1075.  
  1076.       if ((Tree_NoCodeClass & W_6->Properties) == 0X0L && IN(Tree_HasChildren, W_6->Properties)) {
  1077.         IO_WriteS(Tree_f, (STRING)"| ", 2L);
  1078.         Tree_WI(W_6->Name);
  1079.         IO_WriteS(Tree_f, (STRING)":", 1L);
  1080.         IO_WriteNl(Tree_f);
  1081.         TreeMod2_GetIterator(t);
  1082.         iClassName = W_6->Name;
  1083.         Tree_ForallAttributes(t, (Tree_ProcOfT)Mark);
  1084.         if (TreeMod2_Iterator == Tree_NoTree) {
  1085.           IO_WriteS(Tree_f, (STRING)"RETURN;", 7L);
  1086.           IO_WriteNl(Tree_f);
  1087.         } else {
  1088.           IO_WriteS(Tree_f, (STRING)"yyt := yyt^.", 12L);
  1089.           Tree_WI(iClassName);
  1090.           IO_WriteS(Tree_f, (STRING)".", 1L);
  1091.           Tree_WI(TreeMod2_Iterator->U_1.V_9.Child.Name);
  1092.           IO_WriteS(Tree_f, (STRING)";", 1L);
  1093.           IO_WriteNl(Tree_f);
  1094.         }
  1095.       }
  1096.       return;
  1097.     }
  1098.   }
  1099.   if (t->U_1.V_1.Kind == Tree_Child) {
  1100.     {
  1101.       register Tree_yChild *W_7 = &t->U_1.V_9.Child;
  1102.  
  1103.       if (t != TreeMod2_Iterator) {
  1104.         IO_WriteS(Tree_f, (STRING)"yyMark (yyt^.", 13L);
  1105.         Tree_WI(iClassName);
  1106.         IO_WriteS(Tree_f, (STRING)".", 1L);
  1107.         Tree_WI(W_7->Name);
  1108.         IO_WriteS(Tree_f, (STRING)");", 2L);
  1109.         IO_WriteNl(Tree_f);
  1110.       }
  1111.       return;
  1112.     }
  1113.   }
  1114. }
  1115.  
  1116. static void WriteClassName
  1117. # ifdef __STDC__
  1118. (Tree_tTree t)
  1119. # else
  1120. (t)
  1121. Tree_tTree t;
  1122. # endif
  1123. {
  1124.   struct S_7 yyTempo;
  1125.  
  1126.   if (t == Tree_NoTree) {
  1127.     return;
  1128.   }
  1129.   if (t->U_1.V_1.Kind == Tree_Class) {
  1130.     {
  1131.       register Tree_yClass *W_8 = &t->U_1.V_5.Class;
  1132.  
  1133.       if ((Tree_NoCodeClass & W_8->Properties) == 0X0L) {
  1134.         IO_WriteS(Tree_f, (STRING)"| ", 2L);
  1135.         Tree_WI(W_8->Name);
  1136.         IO_WriteS(Tree_f, (STRING)": ", 2L);
  1137.         if (((SET_ELEM(Tree_HasChildren) | SET_ELEM(Tree_HasAttributes)) & W_8->Properties) != 0X0L) {
  1138.           IO_WriteS(Tree_f, (STRING)"yWrite", 6L);
  1139.           Tree_WI(W_8->Name);
  1140.           IO_WriteS(Tree_f, (STRING)" (yyt); ", 8L);
  1141.           TreeMod2_GetIterator(t);
  1142.           if (TreeMod2_Iterator == Tree_NoTree) {
  1143.             IO_WriteS(Tree_f, (STRING)"EXIT;", 5L);
  1144.             IO_WriteNl(Tree_f);
  1145.           } else {
  1146.             IO_WriteS(Tree_f, (STRING)"yyIndentSelector ('", 19L);
  1147.             Tree_WI(TreeMod2_Iterator->U_1.V_9.Child.Name);
  1148.             IO_WriteS(Tree_f, (STRING)"'); ", 4L);
  1149.             IO_WriteS(Tree_f, (STRING)"yyt := yyt^.", 12L);
  1150.             Tree_WI(W_8->Name);
  1151.             IO_WriteS(Tree_f, (STRING)".", 1L);
  1152.             Tree_WI(TreeMod2_Iterator->U_1.V_9.Child.Name);
  1153.             IO_WriteS(Tree_f, (STRING)";", 1L);
  1154.             IO_WriteNl(Tree_f);
  1155.           }
  1156.         } else {
  1157.           IO_WriteS(Tree_f, (STRING)"IO.WriteS (yyf, '", 17L);
  1158.           Tree_WI(W_8->Name);
  1159.           IO_WriteS(Tree_f, (STRING)"'); yyWriteNl; EXIT;", 20L);
  1160.           IO_WriteNl(Tree_f);
  1161.         }
  1162.       }
  1163.       return;
  1164.     }
  1165.   }
  1166. }
  1167.  
  1168. static void WriteAttributes
  1169. # ifdef __STDC__
  1170. (Tree_tTree t)
  1171. # else
  1172. (t)
  1173. Tree_tTree t;
  1174. # endif
  1175. {
  1176.   struct S_8 yyTempo;
  1177.  
  1178.   if (t == Tree_NoTree) {
  1179.     return;
  1180.   }
  1181.   if (t->U_1.V_1.Kind == Tree_Class) {
  1182.     {
  1183.       register Tree_yClass *W_9 = &t->U_1.V_5.Class;
  1184.  
  1185.       if ((Tree_NoCodeClass & W_9->Properties) == 0X0L && ((SET_ELEM(Tree_HasChildren) | SET_ELEM(Tree_HasAttributes)) & W_9->Properties) != 0X0L) {
  1186.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yWrite", 16L);
  1187.         Tree_WI(W_9->Name);
  1188.         IO_WriteS(Tree_f, (STRING)" (yyt: ", 7L);
  1189.         Tree_WI(Tree_itTree);
  1190.         IO_WriteS(Tree_f, (STRING)");", 2L);
  1191.         IO_WriteNl(Tree_f);
  1192.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  1193.         IO_WriteNl(Tree_f);
  1194.         IO_WriteS(Tree_f, (STRING)"  IO.WriteS (yyf, '", 19L);
  1195.         Tree_WI(W_9->Name);
  1196.         IO_WriteS(Tree_f, (STRING)"'); yyWriteNl;", 14L);
  1197.         IO_WriteNl(Tree_f);
  1198.         TreeMod2_GetIterator(t);
  1199.         iClassName = W_9->Name;
  1200.         Tree_ForallAttributes(t, (Tree_ProcOfT)WriteAttributes);
  1201.         IO_WriteS(Tree_f, (STRING)" END yWrite", 11L);
  1202.         Tree_WI(W_9->Name);
  1203.         IO_WriteS(Tree_f, (STRING)";", 1L);
  1204.         IO_WriteNl(Tree_f);
  1205.         IO_WriteNl(Tree_f);
  1206.       }
  1207.       return;
  1208.     }
  1209.   }
  1210.   if (t->U_1.V_1.Kind == Tree_Child) {
  1211.     {
  1212.       register Tree_yChild *W_10 = &t->U_1.V_9.Child;
  1213.  
  1214.       if (t != TreeMod2_Iterator) {
  1215.         IO_WriteS(Tree_f, (STRING)"  yyIndentSelectorTree ('", 25L);
  1216.         Tree_WI(W_10->Name);
  1217.         IO_WriteS(Tree_f, (STRING)"', yyt^.", 8L);
  1218.         Tree_WI(iClassName);
  1219.         IO_WriteS(Tree_f, (STRING)".", 1L);
  1220.         Tree_WI(W_10->Name);
  1221.         IO_WriteS(Tree_f, (STRING)");", 2L);
  1222.         IO_WriteNl(Tree_f);
  1223.       }
  1224.       return;
  1225.     }
  1226.   }
  1227.   if (t->U_1.V_1.Kind == Tree_Attribute) {
  1228.     {
  1229.       register Tree_yAttribute *W_11 = &t->U_1.V_10.Attribute;
  1230.  
  1231.       if ((Tree_NoCodeAttr & W_11->Properties) == 0X0L) {
  1232.         IO_WriteS(Tree_f, (STRING)"  yyIndentSelector ('", 21L);
  1233.         Tree_WI(W_11->Name);
  1234.         IO_WriteS(Tree_f, (STRING)"'); ", 4L);
  1235.         IO_WriteS(Tree_f, (STRING)"write", 5L);
  1236.         Tree_WI(W_11->Type);
  1237.         IO_WriteS(Tree_f, (STRING)" (yyt^.", 7L);
  1238.         Tree_WI(iClassName);
  1239.         IO_WriteS(Tree_f, (STRING)".", 1L);
  1240.         Tree_WI(W_11->Name);
  1241.         IO_WriteS(Tree_f, (STRING)") yyWriteNl;", 12L);
  1242.         IO_WriteNl(Tree_f);
  1243.       }
  1244.       return;
  1245.     }
  1246.   }
  1247. }
  1248.  
  1249. static void ReadAttributes
  1250. # ifdef __STDC__
  1251. (Tree_tTree t)
  1252. # else
  1253. (t)
  1254. Tree_tTree t;
  1255. # endif
  1256. {
  1257.   struct S_9 yyTempo;
  1258.  
  1259.   if (t == Tree_NoTree) {
  1260.     return;
  1261.   }
  1262.   if (t->U_1.V_1.Kind == Tree_Class) {
  1263.     {
  1264.       register Tree_yClass *W_12 = &t->U_1.V_5.Class;
  1265.  
  1266.       if ((Tree_NoCodeClass & W_12->Properties) == 0X0L && ((SET_ELEM(Tree_HasChildren) | SET_ELEM(Tree_HasAttributes)) & W_12->Properties) != 0X0L) {
  1267.         IO_WriteS(Tree_f, (STRING)"| ", 2L);
  1268.         Tree_WI(W_12->Name);
  1269.         IO_WriteS(Tree_f, (STRING)":", 1L);
  1270.         IO_WriteNl(Tree_f);
  1271.         TreeMod2_GetIterator(t);
  1272.         iClassName = W_12->Name;
  1273.         Tree_ForallAttributes(t, (Tree_ProcOfT)ReadAttributes);
  1274.         if (TreeMod2_Iterator == Tree_NoTree) {
  1275.           IO_WriteS(Tree_f, (STRING)"RETURN;", 7L);
  1276.           IO_WriteNl(Tree_f);
  1277.         } else {
  1278.           IO_WriteS(Tree_f, (STRING)"yySkip; yyt := SYSTEM.ADR (yyt^^.", 33L);
  1279.           Tree_WI(iClassName);
  1280.           IO_WriteS(Tree_f, (STRING)".", 1L);
  1281.           Tree_WI(TreeMod2_Iterator->U_1.V_9.Child.Name);
  1282.           IO_WriteS(Tree_f, (STRING)");", 2L);
  1283.           IO_WriteNl(Tree_f);
  1284.         }
  1285.       }
  1286.       return;
  1287.     }
  1288.   }
  1289.   if (t->U_1.V_1.Kind == Tree_Child) {
  1290.     {
  1291.       register Tree_yChild *W_13 = &t->U_1.V_9.Child;
  1292.  
  1293.       if (t != TreeMod2_Iterator) {
  1294.         IO_WriteS(Tree_f, (STRING)"yySkip; read", 12L);
  1295.         Tree_WI(Tree_itTree);
  1296.         IO_WriteS(Tree_f, (STRING)" (SYSTEM.ADR (yyt^^.", 20L);
  1297.         Tree_WI(iClassName);
  1298.         IO_WriteS(Tree_f, (STRING)".", 1L);
  1299.         Tree_WI(W_13->Name);
  1300.         IO_WriteS(Tree_f, (STRING)"))", 2L);
  1301.         IO_WriteNl(Tree_f);
  1302.       }
  1303.       return;
  1304.     }
  1305.   }
  1306.   if (t->U_1.V_1.Kind == Tree_Attribute) {
  1307.     {
  1308.       register Tree_yAttribute *W_14 = &t->U_1.V_10.Attribute;
  1309.  
  1310.       if ((Tree_NoCodeAttr & W_14->Properties) == 0X0L) {
  1311.         IO_WriteS(Tree_f, (STRING)"yySkip; read", 12L);
  1312.         Tree_WI(W_14->Type);
  1313.         IO_WriteS(Tree_f, (STRING)" (yyt^^.", 8L);
  1314.         Tree_WI(iClassName);
  1315.         IO_WriteS(Tree_f, (STRING)".", 1L);
  1316.         Tree_WI(W_14->Name);
  1317.         IO_WriteS(Tree_f, (STRING)") yyReadNl;", 11L);
  1318.         IO_WriteNl(Tree_f);
  1319.       }
  1320.       return;
  1321.     }
  1322.   }
  1323. }
  1324.  
  1325. static void PutAttributes
  1326. # ifdef __STDC__
  1327. (Tree_tTree t)
  1328. # else
  1329. (t)
  1330. Tree_tTree t;
  1331. # endif
  1332. {
  1333.   struct S_10 yyTempo;
  1334.  
  1335.   if (t == Tree_NoTree) {
  1336.     return;
  1337.   }
  1338.   if (t->U_1.V_1.Kind == Tree_Class) {
  1339.     {
  1340.       register Tree_yClass *W_15 = &t->U_1.V_5.Class;
  1341.  
  1342.       if ((Tree_NoCodeClass & W_15->Properties) == 0X0L && ((SET_ELEM(Tree_HasChildren) | SET_ELEM(Tree_HasAttributes)) & W_15->Properties) != 0X0L) {
  1343.         IO_WriteS(Tree_f, (STRING)"| ", 2L);
  1344.         Tree_WI(W_15->Name);
  1345.         IO_WriteS(Tree_f, (STRING)":", 1L);
  1346.         IO_WriteNl(Tree_f);
  1347.         TreeMod2_GetIterator(t);
  1348.         iClassName = W_15->Name;
  1349.         Tree_ForallAttributes(t, (Tree_ProcOfT)PutAttributes);
  1350.         if (TreeMod2_Iterator == Tree_NoTree) {
  1351.           IO_WriteS(Tree_f, (STRING)"RETURN;", 7L);
  1352.           IO_WriteNl(Tree_f);
  1353.         } else {
  1354.           IO_WriteS(Tree_f, (STRING)"yyt := yyt^.", 12L);
  1355.           Tree_WI(iClassName);
  1356.           IO_WriteS(Tree_f, (STRING)".", 1L);
  1357.           Tree_WI(TreeMod2_Iterator->U_1.V_9.Child.Name);
  1358.           IO_WriteS(Tree_f, (STRING)";", 1L);
  1359.           IO_WriteNl(Tree_f);
  1360.         }
  1361.       }
  1362.       return;
  1363.     }
  1364.   }
  1365.   if (t->U_1.V_1.Kind == Tree_Child) {
  1366.     {
  1367.       register Tree_yChild *W_16 = &t->U_1.V_9.Child;
  1368.  
  1369.       if (t != TreeMod2_Iterator) {
  1370.         IO_WriteS(Tree_f, (STRING)"put", 3L);
  1371.         Tree_WI(Tree_itTree);
  1372.         IO_WriteS(Tree_f, (STRING)" (yyt^.", 7L);
  1373.         Tree_WI(iClassName);
  1374.         IO_WriteS(Tree_f, (STRING)".", 1L);
  1375.         Tree_WI(W_16->Name);
  1376.         IO_WriteS(Tree_f, (STRING)")", 1L);
  1377.         IO_WriteNl(Tree_f);
  1378.       }
  1379.       return;
  1380.     }
  1381.   }
  1382.   if (t->U_1.V_1.Kind == Tree_Attribute) {
  1383.     {
  1384.       register Tree_yAttribute *W_17 = &t->U_1.V_10.Attribute;
  1385.  
  1386.       if ((Tree_NoCodeAttr & W_17->Properties) == 0X0L) {
  1387.         IO_WriteS(Tree_f, (STRING)"put", 3L);
  1388.         Tree_WI(W_17->Type);
  1389.         IO_WriteS(Tree_f, (STRING)" (yyt^.", 7L);
  1390.         Tree_WI(iClassName);
  1391.         IO_WriteS(Tree_f, (STRING)".", 1L);
  1392.         Tree_WI(W_17->Name);
  1393.         IO_WriteS(Tree_f, (STRING)")", 1L);
  1394.         IO_WriteNl(Tree_f);
  1395.       }
  1396.       return;
  1397.     }
  1398.   }
  1399. }
  1400.  
  1401. static void GetAttributes
  1402. # ifdef __STDC__
  1403. (Tree_tTree t)
  1404. # else
  1405. (t)
  1406. Tree_tTree t;
  1407. # endif
  1408. {
  1409.   struct S_11 yyTempo;
  1410.  
  1411.   if (t == Tree_NoTree) {
  1412.     return;
  1413.   }
  1414.   if (t->U_1.V_1.Kind == Tree_Class) {
  1415.     {
  1416.       register Tree_yClass *W_18 = &t->U_1.V_5.Class;
  1417.  
  1418.       if ((Tree_NoCodeClass & W_18->Properties) == 0X0L && ((SET_ELEM(Tree_HasChildren) | SET_ELEM(Tree_HasAttributes)) & W_18->Properties) != 0X0L) {
  1419.         IO_WriteS(Tree_f, (STRING)"| ", 2L);
  1420.         Tree_WI(W_18->Name);
  1421.         IO_WriteS(Tree_f, (STRING)":", 1L);
  1422.         IO_WriteNl(Tree_f);
  1423.         TreeMod2_GetIterator(t);
  1424.         iClassName = W_18->Name;
  1425.         Tree_ForallAttributes(t, (Tree_ProcOfT)GetAttributes);
  1426.         if (TreeMod2_Iterator == Tree_NoTree) {
  1427.           IO_WriteS(Tree_f, (STRING)"RETURN;", 7L);
  1428.           IO_WriteNl(Tree_f);
  1429.         } else {
  1430.           IO_WriteS(Tree_f, (STRING)"yyt := SYSTEM.ADR (yyt^^.", 25L);
  1431.           Tree_WI(iClassName);
  1432.           IO_WriteS(Tree_f, (STRING)".", 1L);
  1433.           Tree_WI(TreeMod2_Iterator->U_1.V_9.Child.Name);
  1434.           IO_WriteS(Tree_f, (STRING)");", 2L);
  1435.           IO_WriteNl(Tree_f);
  1436.         }
  1437.       }
  1438.       return;
  1439.     }
  1440.   }
  1441.   if (t->U_1.V_1.Kind == Tree_Child) {
  1442.     {
  1443.       register Tree_yChild *W_19 = &t->U_1.V_9.Child;
  1444.  
  1445.       if (t != TreeMod2_Iterator) {
  1446.         IO_WriteS(Tree_f, (STRING)"get", 3L);
  1447.         Tree_WI(Tree_itTree);
  1448.         IO_WriteS(Tree_f, (STRING)" (SYSTEM.ADR (yyt^^.", 20L);
  1449.         Tree_WI(iClassName);
  1450.         IO_WriteS(Tree_f, (STRING)".", 1L);
  1451.         Tree_WI(W_19->Name);
  1452.         IO_WriteS(Tree_f, (STRING)"))", 2L);
  1453.         IO_WriteNl(Tree_f);
  1454.       }
  1455.       return;
  1456.     }
  1457.   }
  1458.   if (t->U_1.V_1.Kind == Tree_Attribute) {
  1459.     {
  1460.       register Tree_yAttribute *W_20 = &t->U_1.V_10.Attribute;
  1461.  
  1462.       if ((Tree_NoCodeAttr & W_20->Properties) == 0X0L) {
  1463.         IO_WriteS(Tree_f, (STRING)"get", 3L);
  1464.         Tree_WI(W_20->Type);
  1465.         IO_WriteS(Tree_f, (STRING)" (yyt^^.", 8L);
  1466.         Tree_WI(iClassName);
  1467.         IO_WriteS(Tree_f, (STRING)".", 1L);
  1468.         Tree_WI(W_20->Name);
  1469.         IO_WriteS(Tree_f, (STRING)")", 1L);
  1470.         IO_WriteNl(Tree_f);
  1471.       }
  1472.       return;
  1473.     }
  1474.   }
  1475. }
  1476.  
  1477. static void InitKindToIdent
  1478. # ifdef __STDC__
  1479. (Tree_tTree t)
  1480. # else
  1481. (t)
  1482. Tree_tTree t;
  1483. # endif
  1484. {
  1485.   struct S_12 yyTempo;
  1486.  
  1487.   if (t == Tree_NoTree) {
  1488.     return;
  1489.   }
  1490.   if (t->U_1.V_1.Kind == Tree_Class) {
  1491.     {
  1492.       register Tree_yClass *W_21 = &t->U_1.V_5.Class;
  1493.  
  1494.       if ((Tree_NoCodeClass & W_21->Properties) == 0X0L) {
  1495.         IO_WriteS(Tree_f, (STRING)"  yyInitKindToIdent2 ('", 23L);
  1496.         Tree_WI(W_21->Name);
  1497.         IO_WriteS(Tree_f, (STRING)"', ", 3L);
  1498.         Tree_WI(W_21->Name);
  1499.         IO_WriteS(Tree_f, (STRING)");", 2L);
  1500.         IO_WriteNl(Tree_f);
  1501.       }
  1502.       return;
  1503.     }
  1504.   }
  1505. }
  1506.  
  1507. void TreeMod2_GetIterator
  1508. # ifdef __STDC__
  1509. (Tree_tTree t)
  1510. # else
  1511. (t)
  1512. Tree_tTree t;
  1513. # endif
  1514. {
  1515.   struct S_13 yyTempo;
  1516.  
  1517.   if (t == Tree_NoTree) {
  1518.     return;
  1519.   }
  1520.   if (t->U_1.V_1.Kind == Tree_Class) {
  1521.     {
  1522.       register Tree_yClass *W_22 = &t->U_1.V_5.Class;
  1523.  
  1524.       TreeMod2_Iterator = Tree_NoTree;
  1525.       RevChild = Tree_NoTree;
  1526.       Tree_ForallAttributes(t, (Tree_ProcOfT)TreeMod2_GetIterator);
  1527.       if (RevChild != Tree_NoTree) {
  1528.         TreeMod2_Iterator = RevChild;
  1529.       }
  1530.       return;
  1531.     }
  1532.   }
  1533.   if (t->U_1.V_1.Kind == Tree_Child) {
  1534.     {
  1535.       register Tree_yChild *W_23 = &t->U_1.V_9.Child;
  1536.  
  1537.       TreeMod2_Iterator = t;
  1538.       if (IN(Tree_Reverse, W_23->Properties)) {
  1539.         RevChild = t;
  1540.       }
  1541.       return;
  1542.     }
  1543.   }
  1544. }
  1545.  
  1546. void TreeMod2_BeginTreeMod2
  1547. # ifdef __STDC__
  1548. ()
  1549. # else
  1550. ()
  1551. # endif
  1552. {
  1553. }
  1554.  
  1555. void TreeMod2_CloseTreeMod2
  1556. # ifdef __STDC__
  1557. ()
  1558. # else
  1559. ()
  1560. # endif
  1561. {
  1562. }
  1563.  
  1564. static void yyExit
  1565. # ifdef __STDC__
  1566. ()
  1567. # else
  1568. ()
  1569. # endif
  1570. {
  1571.   IO_CloseIO();
  1572.   Exit(1L);
  1573. }
  1574.  
  1575. void BEGIN_TreeMod2()
  1576. {
  1577.   static BOOLEAN has_been_called = FALSE;
  1578.  
  1579.   if (!has_been_called) {
  1580.     has_been_called = TRUE;
  1581.  
  1582.     BEGIN_IO();
  1583.     BEGIN_Tree();
  1584.     BEGIN_Positions();
  1585.     BEGIN_System();
  1586.     BEGIN_IO();
  1587.     BEGIN_Tree();
  1588.     BEGIN_IO();
  1589.     BEGIN_Sets();
  1590.     BEGIN_Idents();
  1591.     BEGIN_Positions();
  1592.     BEGIN_Tree();
  1593.  
  1594.     TreeMod2_yyf = IO_StdOutput;
  1595.     TreeMod2_Exit = yyExit;
  1596.     TreeMod2_BeginTreeMod2();
  1597.   }
  1598. }
  1599.